package com.eduagent.xwqeduagent.api.RealTimeVoiceToTextConversion.model;

import com.alibaba.fastjson.JSONObject;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 实时语音转写结果
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ASRResult {
    /**
     * 结果标识
     * started: 握手成功
     * result: 转写结果
     * error: 异常
     */
    private String action;
    
    /**
     * 结果码
     */
    private String code;
    
    /**
     * 结果数据
     */
    private String data;
    
    /**
     * 描述信息
     */
    private String desc;
    
    /**
     * 会话ID
     */
    private String sid;
    
    /**
     * 解析后的转写结果（仅当action为result且解析成功时有值）
     */
    private ASRTranscription transcription;
    
    /**
     * 解析后的翻译结果（仅当开启翻译功能且解析成功时有值）
     */
    private ASRTranslation translation;
    
    /**
     * 从JSON字符串解析实时语音转写结果
     * 
     * @param jsonString JSON字符串
     * @return 解析后的结果
     */
    public static ASRResult fromJson(String jsonString) {
        try {
            JSONObject json = JSONObject.parseObject(jsonString);
            ASRResult result = new ASRResult();
            result.setAction(json.getString("action"));
            result.setCode(json.getString("code"));
            result.setData(json.getString("data"));
            result.setDesc(json.getString("desc"));
            result.setSid(json.getString("sid"));
            
            // 如果是结果数据并且data不为空，尝试解析data内容
            if ("result".equals(result.getAction()) && result.getData() != null && !result.getData().isEmpty()) {
                try {
                    JSONObject dataJson = JSONObject.parseObject(result.getData());
                    
                    // 检查是否为翻译结果 (biz字段存在且为"trans")
                    if (dataJson.containsKey("biz") && "trans".equals(dataJson.getString("biz"))) {
                        ASRTranslation translation = new ASRTranslation();
                        translation.setSrc(dataJson.getString("src"));
                        translation.setDst(dataJson.getString("dst"));
                        translation.setSegId(dataJson.getInteger("segId"));
                        translation.setIsEnd(dataJson.getBooleanValue("isEnd"));
                        translation.setType(dataJson.getInteger("type"));
                        translation.setBg(dataJson.getLong("bg"));
                        translation.setEd(dataJson.getLong("ed"));
                        result.setTranslation(translation);
                    }
                    // 普通转写结果
                    else if (dataJson.containsKey("cn")) {
                        ASRTranscription transcription = new ASRTranscription();
                        transcription.setSegId(dataJson.getInteger("seg_id"));
                        
                        JSONObject cnJson = dataJson.getJSONObject("cn");
                        JSONObject stJson = cnJson.getJSONObject("st");
                        
                        transcription.setBg(stJson.getLong("bg"));
                        transcription.setEd(stJson.getLong("ed"));
                        transcription.setType(stJson.getString("type"));
                        
                        StringBuilder textBuilder = new StringBuilder();
                        JSONObject rtJson = stJson.getJSONArray("rt").getJSONObject(0);
                        for (Object wsObj : rtJson.getJSONArray("ws")) {
                            JSONObject ws = (JSONObject) wsObj;
                            JSONObject cw = ws.getJSONArray("cw").getJSONObject(0);
                            textBuilder.append(cw.getString("w"));
                        }
                        
                        transcription.setText(textBuilder.toString());
                        result.setTranscription(transcription);
                    }
                } catch (Exception e) {
                    // 解析出错，不影响原始结果返回
                    System.err.println("解析转写结果失败: " + e.getMessage());
                }
            }
            
            return result;
        } catch (Exception e) {
            throw new RuntimeException("解析实时语音转写结果失败", e);
        }
    }
    
    /**
     * 判断是否为最终结果
     */
    public boolean isFinal() {
        return transcription != null && "0".equals(transcription.getType());
    }
    
    /**
     * 判断是否为中间结果
     */
    public boolean isIntermediate() {
        return transcription != null && "1".equals(transcription.getType());
    }
    
    /**
     * 判断是否为翻译结果
     */
    public boolean isTranslation() {
        return translation != null;
    }
    
    /**
     * 获取纯文本结果
     */
    public String getPlainText() {
        if (transcription != null) {
            return transcription.getText();
        } else if (translation != null) {
            return translation.getDst();
        }
        return null;
    }
    
    /**
     * 实时语音转写结果 - 转写内容
     */
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public static class ASRTranscription {
        /**
         * 转写结果序号
         */
        private Integer segId;
        
        /**
         * 句子在整段语音中的开始时间，单位毫秒(ms)
         */
        private Long bg;
        
        /**
         * 句子在整段语音中的结束时间，单位毫秒(ms)
         */
        private Long ed;
        
        /**
         * 结果类型标识
         * 0: 最终结果
         * 1: 中间结果
         */
        private String type;
        
        /**
         * 解析后的转写文本
         */
        private String text;
    }
    
    /**
     * 实时语音转写结果 - 翻译内容
     */
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public static class ASRTranslation {
        /**
         * 转写结果序号
         */
        private Integer segId;
        
        /**
         * 原始文本
         */
        private String src;
        
        /**
         * 翻译后的文本
         */
        private String dst;
        
        /**
         * 结果类型
         */
        private Integer type;
        
        /**
         * 是否为最后一个翻译结果
         */
        private Boolean isEnd;
        
        /**
         * 句子在整段语音中的开始时间，单位毫秒(ms)
         */
        private Long bg;
        
        /**
         * 句子在整段语音中的结束时间，单位毫秒(ms)
         */
        private Long ed;
    }
} 